System, apparatus and methods to implement high-speed network analyzers

ABSTRACT

Systems, apparatus and methods for the implementation of high-speed network analyzers are provided. A set of high-level specifications is used to define the behavior of the network analyzer emitted by a compiler. An optimized inline workflow to process regular expressions is presented without sacrificing the semantic capabilities of the processing engine. An optimized packet dispatcher implements a subset of the functions implemented by the network analyzer, providing a fast and slow path workflow used to accelerate specific processing units. Such dispatcher facility can also be used as a cache of policies, wherein if a policy is found, then packet manipulations associated with the policy can be quickly performed. An optimized method of generating DFA specifications for network signatures is also presented. The method accepts several optimization criteria, such as min-max allocations or optimal allocations based on the probability of occurrence of each signature input bit.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is related to and claims the benefit of priority to U.S. Provisional Application Ser. No. 61/174,325 entitled “COMPILATION AND OPTIMIZATION OF PROTOCOL ANALYZERS”, filed Apr. 30, 2009, the entirety of which is hereby incorporated by reference.

GOVERNMENT INTEREST

Portions of this invention were made with U.S. Government support under contract/instrument Department of Energy SBIR DE-FG02-08ER85046 The U.S. Government has certain rights.

FIELD OF THE INVENTION

The present invention generally concerns high-speed network analyzers. More particularly, the invention concerns a system and its methods for identifying intelligent patterns within streams of data observed at high-speed rates.

BACKGROUND OF THE INVENTION

The process of developing technology often involves two parallel efforts: (1) the development of a new technology and (2) the development of peripheral tools for the performance analysis and behavior evaluation of the technology itself. While the field of computer science provides uncountable examples of technologies that have been developed hand in hand with such peripheral tools, two of these technologies have taken a pivotal place during the past fifty years: the computer and the Internet.

There exist at least two broad reasons for the need of analytical tools to measure the performance and behavior of Internet computing systems. First, at the early stages of development, systems are simple and their performance can usually be characterized through direct naked-eye observation. As the technology matures, its complexity increases, often to a point where its behavior is no longer easy to predict. The Internet provides a good example of such evolutionary transition. Its current behavior is both a function of (arguably) predictable computer behavior and unpredictable psychology-based human behavior. Such is the case that computer scientists have long tried to model its behavior borrowing tools from branches of math such as stochastic processes, game theory or even fractal and chaos theory. (A. B. Mackenzie, S. B. Wicker, Game theory in communications: motivation, explanation, and application to power control, IEEE Global Telecommunications Conference, 2001; M. E. Crovella, A. Bestavros, Self-similarity in World Wide Web Traffic: Evidence and Possible Causes, IEEE/ACM Transactions on Networking, 1996.) This evolutionary need for performance analysis tools arises in most of the technologies that achieve certain complexity.

Second, for the past fifty years, our economic and social superstructures have evolved to a point where almost any transaction (both economic and social) requires some form of involvement of the Internet and our computer systems. Key resources such as energy, water, communication or the stock market, to name a few, depend on the proper functioning of these two technologies. Such is the case that they are recognized as national security infrastructures subject to possible cyber attacks. (V. Paxson, Bro: A System for Detecting Network Intruders in Real-Time, Proceedings of the 7th USENIX Security Symposium, 1998.) To protect the well-being of our society, it is therefore crucial to dispose high-performance peripheral tools capable of analyzing the behavior of the networks to detect malicious usages.

Current architectures of these analysis tools are being driven to a breaking point by two independent challenges: first, as network data-rates increase, these tools are being overwhelmed by the quantity of computation they must perform to continuously analyze the network; second, as computer network systems become more sophisticated, the parsing of the network flows requires ever more complex traffic analysis heuristics that further stress the system's processing capacity.

Therefore there exists a need for a set of systems and methods that focus on the high-performance implementation of peripheral tools.

BRIEF SUMMARY OF THE INVENTION

Various provided embodiments include a system, apparatus, and methods for addressing many of the two challenges introduced above. In an exemplary embodiment, a method to generate data plane specifications of a network analyzer capable of running in a variety of hardware platforms is provided. The method is based on two core facilities: a high level protocol specification language (HLPSL) used to write input protocols and events specifications, and a compiler capable of translating such specifications into actual native code (the data plane specification) executable on the targeted hardware platform.

In another embodiment, a fast and slow path implementation of a component within the network analysis is provided. The separation of the implementation between fast and slow paths allows for the decoupling of those logical elements that are slow to execute but rarely used from those that are faster and commonly invoked. It is argued that this approach differs from previous work by providing scalability to large number of signatures, and hence that one exemplary application of the present invention is that of large systems supporting a large variety of analysis events.

In yet another embodiment, a packet dispatcher workflow is provided. The dispatcher provides a high-performance optimization framework in which a subset of the network analyzer functions can be offloaded onto a more specialized hardware and software facility. For instance, in an exemplary embodiment, the dispatcher is used to leverage dedicated DFA engines to search for regular expressions of interest in the flow of packets, offloading the network analyzer from such task.

In a further embodiment, a level 1 (L1) policy caching flowchart is provided that enables the following basic dispatcher behavior: upon arrival of a packet P, if a policy associated with P is found in the L1 cache, then execute it; otherwise, forward the packet to the network analyzer. This L1 cache provides yet another framework upon which high-performance optimizations can be implemented. For instance, the cache provides a facility to make early decisions on whether a specific flow requires any further processing or can be bypassed, yielding net savings of processing resources from the network analyzer.

In yet another embodiment, a workflow is presented which illustrates how a single protocol analyzer engine can be used to resolve a large number of signatures in parallel. Given a fixed number of supported protocols, this approach is shown to scale up with the number of signatures up to a certain saturation point.

In yet another embodiment, a method to translate and optimize signatures into binary decision diagrams (BDD) is provided. The method includes an optimization phase which accepts several optimization criteria. In one specific embodiment, a method is provided yielding min-max BDD cuts that can be run in parallel across multiple DFA engines. In another embodiment, a probabilistic method is provided that shows how knowledge of the probabilities of occurrence of the protocol header fields can be used to minimize the average computational cost of resolving a large set of signatures.

BRIEF DESCRIPTION OF THE DRAWINGS

Various embodiments of the present invention taught herein are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings, in which:

FIG. 1 is a block diagram of a provided apparatus, illustrating major components involved in the creation of a network analyzer data plane specification according to a provided embodiment;

FIG. 2 is a block diagram illustrating some of the components forming the inputs and outputs of a provided network analyzer compiler embodiment;

FIG. 3 is a block diagram illustrating the components forming the fast and slow path part of a network analyzer data plane specification embodiment;

FIG. 4 is a schematic diagram showing the inputs to a family of protocol analysis problems and two different provided methods;

FIG. 5 illustrates the performance of two different provided methods;

FIG. 6 is a block diagram illustrating some of the components forming an embodiment of a data plane specification of the network analyzer concerning the front-end dispatcher;

FIG. 7. is a block diagram illustrating some of the components forming an embodiment of a data plane specification of the network analyzer concerning the front-end dispatcher;

FIG. 8 illustrates examples of regular expressions coming from different sources within the set of input specifications; according to a provided embodiment;

FIG. 9 is a flowchart illustrating a provided method for implementing a level 1 (L1) cache of connection policies according to one provided embodiment;

FIG. 10 is a block diagram describing the loading of static and dynamic policies from the network analyzer to the dispatcher consistent with provided embodiments;

FIG. 11 is a block diagram illustrating some of the components forming one embodiment of a data plane specification of the network analyzer illustrating the extraction of information from the network flows and the processing of events;

FIG. 12 illustrates how one provided embodiment scales up with the number of signatures and supported protocols;

FIG. 13 is a block diagram illustrating a provided process of converting and optimizing a set of signatures representable by Boolean functions into DFA specifications;

FIG. 14 illustrates an example of signature and its pseudo-code representation as the first stage in the process of generating a DFA specification;

FIG. 15 illustrates an example of the CNF representation of a signature and its corresponding BDD as an intermediary stage in the process of generating a DFA specification;

FIG. 16 illustrates a graphical example of a BDD corresponding to a signature as an intermediary stage in the process of generating a DFA specification;

FIG. 17 illustrates a graphical example of a set of min-max optimal BDD partitions corresponding to a complete DFA specification of a signature;

FIG. 18 is a flowchart illustrating a method to optimize BDD partitions for the mapping onto DFA engines;

FIG. 19 is a schematic diagram explaining a probabilistic model to optimize the process of mapping signatures onto DFA engines; and

FIG. 20 illustrates a custom computing apparatus and computer software product consistent with provided embodiments.

It will be recognized that some or all of the Figures are schematic representations for purposes of illustration and do not necessarily depict the actual relative sizes or locations of the elements shown. The Figures are provided for the purpose of illustrating one or more embodiments with the explicit understanding that they will not be used to limit the scope or the meaning of the claims.

DETAILED DESCRIPTION OF THE INVENTION

In the following paragraphs, the present invention will be described in detail by way of example with reference to the attached drawings. While this invention is capable of embodiment in many different forms, there is shown in the drawings and will herein be described in detail specific embodiments, with the understanding that the present disclosure is to be considered as an example of the principles of the invention and not intended to limit the invention to the specific embodiments shown and described. That is, throughout this description, the embodiments and examples shown should be considered as exemplars, rather than as limitations on the present invention. Descriptions of well known components, methods and/or processing techniques are omitted so as to not unnecessarily obscure the invention. As used herein, the “present invention” refers to any one of the embodiments of the invention described herein, and any equivalents. Furthermore, reference to various feature(s) of the “present invention” throughout this document does not mean that all claimed embodiments or methods must include the referenced feature(s).

As is known in the art, a network may employ wireless, wired, and optical media as the media for communication. Further, in some embodiments, portions of network may comprise the Public Switched Telephone Network (PSTN). Networks, as used herein may be classified by range. For example, local area networks, wide area networks, metropolitan area networks, and personal area networks. Additionally, networks may be classified by communications media, such as wireless networks and optical networks. Further, some networks may contain portions in which multiple media are employed. For example, in modern television distribution networks, Hybrid-Fiber Coax networks are typically employed. In these networks, optical fiber is used from the “head end” out to distribution nodes in the field. At a distribution node communications content is mapped onto a coaxial media for distribution to a customer's premises. In many environments, the Internet is mapped into these Hybrid Fiber Coax networks providing high-speed Internet access to customer premises through a “cable-modem.” In these types of networks, electronic devices may comprise computers, laptop computers, and servers to name a few. Some portions of these networks may be wireless through the use of wireless technologies such as a technology commonly known as “WiFi,” which is currently specified by the IEEE as 802.11 and its variants, which are typically alphabetically designated as 802.11a, 802.11b, 802.11g, and 802.11n, to name a few.

Portions of a network may additionally include wireless networks that are typically designated as “cellular networks”. In many of these networks, Internet traffic is routed through high-speed “packet-switched” or “circuit-switched” data channels that may be associated to traditional voice channels. In these networks, electronic devices may include cell phones, PDAs, laptop computers, or other types of portable electronic devices. Additionally, metropolitan area networks may include 3^(rd) and 4^(th) generation wireless networks employing an alternate wide area, or metropolitan area wireless technology. 3G and 4G wireless networks are currently specified by both of the 3^(rd) Generation Partnership Projects (3GPP and 3GPP2) Further personal area networks are known in the art. Many of these personal area networks employ a frequency-hopping wireless technology. Other personal area networks may employ a technology known as Ultra-Wideband (UWB). The hallmark of personal area networks is their limited range, and in some instances very high data rates. Since many types of networks and underlying communication technologies are known in the art, various embodiments of the present invention will not therefore be limited with respect to the type of network or the underlying communication technology.

For purposes of clarity the term network as used herein specifically includes but is not limited to the following networks: a wireless communication network, a local area network, a wide area network, a client-server network, a peer-to-peer network, a wireless local area network, a wireless wide area network, a cellular network, a public switched telephone network, and the Internet.

As used in this application, the terms “component,” “module,” “system,” and the like are intended to refer to a computer-related entity, either hardware, firmware, a combination of hardware and software, software, or software in execution. For example, a component can be, but is not limited to being, a process running on a processor, an integrated circuit, an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a computing device and the computing device can be a component. One or more components can reside within a process and/or thread of execution and a component can be localized on one computer and/or distributed between two or more computers. In addition, these components can execute from various non-transitory computer readable media having various data structures stored thereon. The components can communicate by way of local and/or remote processes such as in accordance with a signal having one or more data packets (e.g., data from one component interacting with another component in a local system, distributed system, and/or across a network such as the Internet with other systems by way of the signal).

Referring to FIG. 1, which illustrates an exemplary embodiment of a network analyzer 100 for data plane specifications generation. As illustrated, the network analyzer 100 contains interfaces, a management plane and a data plane. In this embodiment, network analyzer 100 contains a network analyzer compiler 107 with an event interface 106 and a protocol interface 103. In some embodiments, event interface 106 is configured to receive an event specification 105. Additionally, protocol interface 103 is configured to receive a protocol specification 102.

In some embodiments, the inputs to the network analyzer compiler 100 are expressed in a high-level protocol specification language (HLPSL). The input to the protocol interface 103 originates from a protocol specification source 101. This specification can be expressed in a form different than the HLPSL. Examples of protocol source specifications are Internet Engineering Task Force (IETF) Request For Comments (RFCs) such as HTTP specification (R. Fielding, Hypertext Transfer Protocol—HTTP/1.1, Request for Comments RFC2616, 1999), or protocols specified in Backus-Naur Form (BNF). The protocol specification source is translated into an equivalent protocol specification 102 written in the HLPSL 102. The HLPSL defines a human readable grammar that is close to the language used to represent the protocol specification source 101, so that the process of translating one to another is generally straightforward. This translation process can be made manually or automatically via a simple domain-specific compiler.

Two examples of HLPSL that can be used within the scope of various embodiments are GAPAL (N. Borisov, D. J. Brumley, H. J. Wang, J. Dunagan, P. Joshi, and C. Guo, A Generic Application-Level Protocol Analyzer and its Language, Proceedings of the 14th Annual Network & Distributed System Security Symposium, March 2007) and BinPAC (R. Pang, V. Paxson, R. Sommer, L. Peterson, binpac: A yacc for Writing Application Protocol Parsers, Proceedings of ACM Internet Measurement Conference, October 2006). The protocol specification expressed in the HLPSL is used as an input to the protocol interface 103 in the network analyzer compiler module 107. Protocol specifications 102 written in HLPSL can be kept in storage 104 and be reused across different applications.

In some embodiments, the same HLPSL (or in some embodiments an extension of the same HLPSL) is used to describe the events that are relevant to the analysis. This event specification 105 is used as another input to the network analyzer compiler module 107 through event interface 106.

These two sets of specifications form the inputs to the network analyzer compiler 107, also referred as the management plane, which emits a set of data plane specifications for a particular data plane module 108 implementing the actual network analyzer. In an exemplary embodiment, the data plane specifications correspond to native binary code that runs on various hardware engines within the data plane module 108 such as processors, FPGAs, GPUs, ASICs, DFA engines or embedded network processors and hardware acceleration engines, among others.

In various provided embodiments the network analyzer compiler module 107 derives a data plane specification from a protocol specification 102 and an event specification 105. In some instances, the data plane specification contains a set of target events that are grouped or segmented into a fast path and a slow path. In these embodiments, the fast path is typically implemented by a single logical OR of at least two of the target events while the slow path implements each of the target events individually.

In FIG. 2, an exemplary description of the blocks presented in FIG. 1 is presented. In one embodiment, the process of generating an event specification in the HLPSL is obtained from the analysis of the set of actions triggered by a network message. This process starts with receiving a network message or packet in 120, which is used to stress a signature generation module 121. In one embodiment, the signature generation module 121 can be implemented via a computer system which reports traces of the actions triggered by the input message. Such traces are then analyzed by the same signature generation module 121 to emit the actual signature 122. A signature 122 can be understood as a Boolean function that takes as input a network message and returns as output a TRUE value if some relevant action is triggered by the input message.

In one embodiment, the signature generation module 121 emits signatures that return a TRUE statement whenever the input network message attacks a vulnerability of a specific network system. Such signature can then be used by an intrusion detection system (IDS) to protect a network facility from a cyber-attack. An example of this type of signature generation module is presented in J. Newsome, D. Song, Dynamic Taint Analysis for Automatic Detection, Analysis, and Signature Generation of Exploits on Commodity Software, Proceedings of the Network and Distributed System Security Symposium, NDSS 2005.

In FIG. 2, the signature 122 is used as input to a HLPSL signature compiler 123, which is responsible for converting the signature into a specification 124 that conforms to the HLPSL grammar. An example of HLPSL signature compiler is BSC (J. Ros-Giralt, P. Szilagyi, J. Ezick, D. Wohlford, R. Lethin, Generation of High-Performance Protocol-Aware Analyzers with Applications in Intrusion Detection Systems, in Proceedings of SPIE, April 2010), which translates signatures expressed in VinE into BinPAC language. In general, the process will involve an additional stage (an event packing module 125) where the signature is packaged into an event specification 126 in module 125. In this stage, the set of actions that need to be triggered if the signature returns a TRUE statement are added to the HLPSL specification 124 to form the event specification 126. For instance, when used in the context of an IDS, the event can decide to drop, divert, or normalize a flow, among other actions, upon detecting that such flow is malicious (i.e., when the signature returns a TRUE value). The end result is a complete event specification 126 of an event using the HLPSL. Logically, we have that:

EVENT(126)=SIGNATURE(124)+{ACTIONS}  (125)

where {ACTIONS} is the set of actions that must be performed when the signature returns TRUE.

FIG. 2 provides additional detail on exemplary embodiments of the data plane module 108 output. Because events are expressed as actions triggered by Boolean functions, an opportunity exists to optimize the workflow by dividing it into a fast path 133 and a slow path 132. In some embodiments, the data plane module 108 consists of an arbitrary number of protocol analyzer modules 130. Each of the protocol analyzer modules 130 in turn may consist of a protocol parser 131 and a set of events, and each event is made of a signature and a set of actions. If a parser is capable of interpreting a specific protocol P, then it is able to parse any flow that is based on protocol P. For instance, an HTTP parser is able to parse all flows that are based on HTTP. In some provided embodiments, the event specification contains at least one target signature and an action to be invoked if and when the target signature is triggered or found within a data stream. In other embodiments the signature compiler translates a function from one source into one compatible with a conventional computer compiler system. In other provided embodiments, the event packing module 125 associates an equivalent signature with an action to be invoked when the signature is triggered.

FIG. 3 provides further detail on embodiments of the portions of FIG. 2 that refer to the fast path 133 and slow path 132 implementations. In an exemplary embodiment, a fast path 133 is defined as a signature equal to the OR of all the signatures associated with the events in that parser. When a message is received by the parser, it first invokes the OR signature 134. If the OR signature 134 returns FALSE, then the message is irrelevant to the analysis (since all the signatures must return FALSE) and no further action needs to be carried out. Otherwise, if the OR signature 134 returns TRUE, then the slow path 132 is invoked. The slow path 132 consists of the execution of each signature 135 separately. In the slow path 132, the system will execute the event actions associated with those signatures that return TRUE.

The fast path 133 implementation improves the performance of the system if the following holds:

1. with a large probability, the fast path 133 returns FALSE; and

2. it is faster to execute the fast path 133 than the slow path 132.

Notice that if the first condition does not hold, then for most of the cases the system will need to invoke both the fast path 133 and the slow path 132, rendering the fast path 133 redundant. The second condition is also required to be consistent with the definition of fast path 133 and slow path 132. It is observed that in the particular embodiment of an IDS, the above conditions are generally satisfied. In an IDS, in average only a small percentage of the traffic corresponds to an attack. (Even though there might exist certain windows of time for which malicious traffic might come in bursts). In addition, notice also that in general the OR signature 134 can be resolved faster than each signature separately because typically signatures 135 will expose redundancies that the OR operator can simplify away.

FIG. 4 compares embodiments of the protocol analyzer architecture in the present invention and that of previous work (N. Schear, D. R. Albrecht, N. Borisov, High-speed Matching of Vulnerability Signatures, Symposium on Recent Advances in Intrusion Detection, September 2008). While the focus of this previous work was in the design of high-speed intrusion detection systems, the comparison can be generalized to the case of a network traffic analyzer configured with real time events that are triggered when traffic satisfies certain conditions parameterizable through Boolean functions (the signatures). In the following explanation, we will refer to this previous work as approach 1, whereas the present invention will be referred as approach 2. The motivation of this comparison is as follows. Efficient execution of events is an important aspect in the design of high performance network analyzers, especially in scenarios where one needs to protect network trunks handling large amounts of traffic (e.g., 100 Gbps). The situation is further exacerbated by the fact that real deployments need to typically handle on the order of thousands of events/signatures. While traditional network traffic analyzers based on pattern-matching can be executed in parallel using hardware optimizations such as embedded DFA engines, no equivalent solution has been produced for the processing of protocol parsers with events/signatures in parallel.

In previous work (FIG. 4 approach 1), relevant results were presented on the acceleration of signatures based on the independent optimization of each signature's protocol parser. This approach focuses on the optimization of the protocol parser of each signature by removing from the protocol definition those elements that are not relevant to the processing of the signature. In embodiments of the present invention (FIG. 4 approach 2), in contrast, as the number of events (and therefore signatures) that need to be handled increases, the parts of the protocol parser that can be omitted become fewer, since a larger variety of signatures will require in general a larger variety of parsed information. In the limit, when the number of signatures is very large, one should expect the need to process most of the protocol elements carried by a flow in order to resolve all the signatures. Therefore, the savings introduced by approach 1 will tend to decrease as the number of signatures increase. In various embodiments of the present invention, instead of optimizing each signature separately with its own protocol parser, the union of all of the signatures is optimized; this allows both the simplification of redundancies across signatures and the execution of all the signatures in parallel leveraging one single complete protocol parser. Further, as it will be described later in a separate embodiment, this approach allows for the parallel execution of the signatures using DFA (deterministic finite automata) hardware engines. In summary, both solutions (approach 1 and approach 2) have their practical applications and market niches: approach 1 is likely to operate well in the case of low number of signatures, whereas approach 2 will tend to do better as the number of signatures increases.

FIG. 5 summarizes the trade-off relationship between approach 1 and approach 2. When the number of signatures is low, using a complete protocol parser to resolve the signatures leads to large number of unnecessary (redundant) parsed elements while the number of redundancies across signatures is low. In this situation, approach 1 will tend to perform well. On the other hand, when the number of signatures is high, nearly all the logic of the protocol parser will be used (yielding few redundant parsing elements) while the number of redundancies across signatures will increase. In this second scenario, the present invention (approach 2) will tend to outperform approach 1.

In another exemplary embodiment of the present invention, FIG. 6 presents an implementation of the data plane module 108 introduced in FIG. 1. The figure describes the architecture and processing of an incoming packet 151 from the time it is received at the physical layer to the time it is delivered to the network analyzer at the application layer. In some embodiments, the workflow distinguishes two contexts: the bottom half (context 1, reference 152) and the upper half (context 2, reference 153). This is done to optimize the matching of tasks and resources. For instance, in one embodiment, the bottom half 152 offers a more limited set of resources and functionalities while delivers its services at high performance, whereas the upper half 153 provides a richer set of functionalities at a lower performance. While not specific to, in an exemplary embodiment this infrastructure is mapped onto the operating system of a computer, where the bottom half 152 corresponds to the kernel OS and the upper half 153 corresponds to user space.

In what follows, and throughout the description of the various provided embodiments, the terms connection and flow are used interchangeably. Upon arrival, a packet 151 is intercepted from the main flow by a dispatcher 160. In one embodiment, the dispatcher 160 can be implemented as a driver module that is dynamically inserted to the system. The packet 151 is first handed to a first worker 154 “worker 1”. Using the packet's 151 IP connection tuple (defined by the IP source and destination address, transport layer source and destination port, and protocol number), the first worker 154 performs a look up operation onto a table of flows in memory block 155 to obtain the connection state “flow” associated with the packet 151. Next, the first worker 154 creates a working item made of the packet buffer and flow i and inserts it to a working queue 156. In general, the first worker 154 can decide to coalesce multiple packets that belong to the same connection into a scatter-gather list of packets, {packets}, and queue it together with the flow state, {flow i, {packets})}, as indicated in FIG. 6. To ensure a correct processing, if a flow requires in-order packet delivery, the first worker 154 will also perform the task of packet re-ordering (for instance in the case of TCP flows).

A deterministic finite automata (DFA) engine 157 is used to process each working item {flow i, {packets}} to extract the relevant regular expressions found within the packet 151. In some embodiments, the DFA engines 157 are loaded at booting time with a set of specifications (the DFA graphs) that define which regular expressions are of interest to the analysis. In one embodiment, this loading operation is triggered by the network analyzer using an out-of-band control channel 162 and such facility can also be used to dynamically modify the set of DFA specifications. In yet another provided implementation, the DFA engines 157 is implemented in hardware, providing a facility to process regular expressions in parallel. Depending on the type of application, such dedicated facility can save substantial amount of computational work from the system's core processors. For instance, previous work by the authors of the present invention (J. Ros-Giralt, P. Szilagyi, J. Ezick, D. Wohlford, R. Lethin, “Generation of High-Performance Protocol-Aware Analyzers with Applications in Intrusion Detection Systems,” SPIE Cyber Security, Situation Management, and Impact Assessment Conference, April 2010, which is incorporated by reference in its entirety) shows that for a typical HTTP request message, offloading of regular expressions onto hardware DFA engines 157 can save about half the total amount of cycles spent by the CPU in processing the complete message, potentially doubling the throughput of the system. In another embodiment, the DFA engines 157 are implemented in software. While such approach does not benefit from the parallel and optimized nature of the hardware DFA engines 157, the system still benefits from doing this processing up front, for instance by enabling early filtering policies that can save future cycles. This will be described in more detail in a separate embodiment.

The DFA engines 157 return the offsets of the regular expressions found within the scatter-gather list of packets, putting a working item of the form {flow i, {packets}, {regex offsets}} back to a queue of results. A second worker 158 “Worker 2” pulls elements from this queue and delivers them back to the system's IP stack 159. The tuple {flow i, {packets}, {regex offsets}} is ultimately delivered to the network analyzer 161. In an exemplary embodiment, the control data {{flow i}, {regex offsets}} is delivered using a separate control channel 163. The network analyzer 161 can then process the packets 151 using the control information provided by the tuple {{flow i}, {regex offsets}}.

In one embodiment, DFA specifications are automatically generated at compile-time by the network analyzer compiler (107, FIG. 1). The network analyzer compiler 107, upon reading the input HLPSL specifications, extracts the relevant regular expressions and generates their corresponding DFA specification. Such regular expressions can come from multiple sources; FIG. 8 presents examples of regular expressions that can be offloaded using this method for the case in which the HLPSL is Bro/BinPAC (R. Pang, V. Paxson, R. Sommer and L. Peterson, binpac: A yacc for Writing Application Protocol Parsers, Proc. ACM IMC, October 2006). The figure provides four examples:

1. Regular expressions obtained from the HLPSL (reference 165): these type of regular expressions are typically explicitly defined following the HLPSL grammar; for instance, in 165, they are defined via the expression “RE/{regular expression}/”.

2. Regular expressions obtained from the code emitted by the compiler 166: these regular expressions can be implicitly identified from the code emitted by the compiler, the bold line defines the search for a regular expression equal to carrier return (CR) and line feed (LF).

3. Regular expressions obtained from protocol-agnostic filters 167: these regular expression can typically be identified from filters that are based on plain pattern matching or minimal protocol interpretation; for instance, in 167, these regular expressions are defined by the expressions “payload/{regular expression}/”.

4. Regular expressions obtained from protocol-aware filters 168: these regular expressions can be found in filters that are protocol intelligent; for instance, 168, these regular expressions can be defined with expressions such as “if ({regular expression} in buffer)”

In one embodiment, the network analyzer compiler 107 is capable of identifying a complete taxonomy of regular expressions such as the one presented above and generates at compile-time the DFA specifications.

Another provided embodiment, illustrated in FIG. 7, is a method that can be implemented within the scope of the dispatcher module 160 presented in FIG. 6. These embodiments (FIG. 7) include apparatus and methods to implement the passing of control data from the dispatcher to the network analyzer. The data flow for this method starts in block 157 (the remaining data flow previously described with respect to FIG. 6). The DFA engines 157 process the incoming data to obtain the set of offsets where the regular expressions of interest are found. One objective is to convey these offsets to the network analyzer in an efficient way. To that end, a cache table 191 is used to store the control information. In some embodiments this cache is indexed with the memory pointers of the packets scanned by the DFA engines. For each scanned packet, the DFA engines store in the cache a record containing the offsets of the regular expressions. Following this procedure, a STORE operation 190 takes as input parameters the pointer to the packet and the results of the DFA engines (the offsets). A record containing these offsets is created and put in the cache using the pointer as the index to store (and later retrieve) the record.

In a one embodiment, the cache can have limited storage capacity. If such limit is reached, the STORE operation is allowed to fail or, alternatively, a STORE operation can cause an existing record to be dropped from the cache. In these situations, certain packets may not have a corresponding record in the cache. Hence, certain look up operations may also fail (what is known as a cache miss). In a particular configuration, this storage capacity can be set to infinite or, more practically, to the maximum storage capacity given by the system. The cache can also be maintained by a variety of garbage collection or record replacement heuristics as is done in traditional caching methods. In yet another embodiment, the cache can be implemented using high performance storage access algorithms including, but not limited to, hash tables or bloom filters.

Building on the same data path previously described above, packets arrive at the network analyzer 161 where, without loss of generality, the work is partitioned into three stages: a preliminary work stage 192, a regular expression processing stage 193 and a third stage 196 where the remaining tasks take. Upon arriving at the regular expression processing stage 193, a packet is processed by a worker 194 which performs a LOOKUP operation onto the cache 191. The LOOKUP operation passes as argument the pointer to the packet, which is then used as the index to retrieve the record associated with such packet. If the LOOKUP operation returns a record (cache hit), then the worker uses the offsets found in it (if any) to identify the location of the regular expressions of interest in the packet. Otherwise, if no record is found (cache miss), the worker falls back to the normal path and invokes the software regular expression module 195.

The usage of a caching system to convey control information from the dispatcher to the network analyzer provides two key advantages: on one hand, portability and interoperability are greatly enhanced, since all the control logic is kept separate from the rest of the system blocks and, with only a few simple hooks, the control path can be easily attached to the dispatcher and the network analyzer; on the other hand, this comes at no (or negligible) performance cost, since the cache can be implemented using traditional high-performance storage access algorithms such as hash tables or bloom filters.

The flowchart in FIG. 9 assumes the existence of two caches: (1) a protocol-based policy cache (PBPC, 181), which given a protocol type P, returns a policy applicable to any flow conforming to P; and (2) a tuple-based policy cache (TBPC, 182), which given an IP tuple T of the form {IP source and destination addresses, transport source and destination ports, and protocol number}, returns a policy applicable to the flow associated with such tuple T.

The method runs as follows. At 170, upon receiving a packet, it checks if the packet can be parsed. If the packet cannot be parsed, then it is forwarded directly to the network analyzer in 179. Otherwise, at 171, it extracts from the packet its protocol type and looks up the PBPC. If a policy entry was not found in the table at 172, it goes to 175. Otherwise, it executes the policy at 173. If the policy requires it to drop the packet at 174, then it is dropped at 180. Otherwise, it goes to 175. At 175, the method extracts the tuple from the packet and looks up the TBPC in the tuple-based policy cache 182. If a policy is not found at 176, it forwards the packet to the network analyzer at 179. Otherwise, it executes the policy at 177. In some embodiments, on a final check, if the policy requires it to drop the packet at 178, then it is dropped at 180. Otherwise, it is forwarded to the network analyzer at 179.

One advantage of the presented methods and apparatus is that of providing a logical level 1 (L1) caching facility to implement packet policies before the packets reach the network analyzer. If the caches return a policy (cache hit), then such policy can be executed immediately by the dispatcher at 160. Otherwise (cache miss), the packet is handed to the network analyzer, which in all cases has the required information to process the packet. From a performance perspective, this caching facility allows for the offloading of processing cycles from the network analyzer onto the dispatcher. For instance, if the policy states that the packet must be dropped, then such decision can be made up front without the need to involve the network analyzer.

In an exemplary embodiment, a cache miss could occur when the incoming packet is IP fragmented. If the dispatcher does not support IP defragmentation, then it will not be able to compute the tuple of an IP fragmented packet; hence, it will not be able to look up the cache table and retrieve a policy, yielding a cache miss. Another example of cache miss could occur when packets of the same connection arrive out of order. If a policy requires in-order delivery and the dispatcher does not support packet reordering, then such scenario should be treated as a cache miss too. In general, any cache miss can be avoided by adding more functionality to the dispatcher. For instance, these two examples of cache misses could be avoided by implementing the functions of IP defragmentation and packet reordering in the dispatcher. Thus, there exists a natural trade-off between number of cache misses and logical complexity of the dispatcher. In some provided embodiments, IP defragmentation and packet reordering are provided, in others they are not.

In one embodiment, policies are loaded from the network analyzer 161 to the dispatcher 160, as shown in FIG. 10. In this embodiment, there can be two types of policies: static policies, which do not change and do not depend on the input traffic, and dynamic policies, which can change with time and are a function of the input traffic.

FIG. 11 illustrates the flow of a provided method that may be used to implement a portion of the protocol analyzer modules 130 in FIG. 2. In this method, packets are processed via two stages. In the first stage 201, a packet arrives and is first processed by the DFA engines 202. The DFA engines 202 are, in some embodiments, preloaded with DFA specifications corresponding to the set of regular expressions relevant to the analysis; the loading of regular expressions can be done statically or dynamically using the control channels provided in FIG. 10. The DFA engines 202 scan the incoming packet in search for the relevant regular expressions; then, they store the offsets of the found regular expressions in a table of offsets 203. Next, the packet is sent to the second stage 204, where it is thoroughly inspected by a protocol parser 205. In some embodiments, the protocol parser 205 relies on the results of the DFA engines 203 to identify regular expressions within the packet. Upon trying to find a specific regular expression R in a packet, the protocol parser 205 checks the table of offsets 203 previously populated by the DFA engines 203; then, in some embodiments, two cases arise. (1) If no entry is found for regular expression R or if it is found but marked as not offloaded, then the protocol parser 205 falls back to using a software based regular expression library 206 to resolve it.

This could happen for multiple reasons; for instance, in some scenarios the network analyzer compiler 107 in FIG. 1 could decide at compile-time that certain regular expressions cannot be offloaded because they would consume too many resources from the DFA engines 203. (To those skilled in the art, this condition is known as DFA state explosion.) If the entry is found, then the protocol parser 205 uses the offset in the entry to identify the position of the regular expression within the packet. In some embodiments, a negative offset can be used to indicate that the regular expression was not found. The protocol parser 205 gathers information for each flow and, as packets are processed, it stores the results of this analysis in a per-flow status table, referred as the status control block or SCB 207. In FIG. 11, the notation SCB(Ti) refers to the status control block 207 of the connection with IP tuple Ti.

Once a status control block SCB(Tj) 207 is fully completed or the analysis for a connection with tuple Tj is finalized, SCB(Tj) 207 is passed to a module that can resolve all the events/signatures in one single pass. This strategy differs from previous work (N. Schear, D. R. Albrecht, N. Borisov, High-speed Matching of Vulnerability Signatures, Symposium on Recent Advances in Intrusion Detection, September 2008) in that instead of implementing a protocol parser for each even/signature, embodiments of the present invention use a single protocol parser 205 to first extract all the required information and then compute all the signatures at once. This strategy allows for the implementation of the fast and slow path as previously introduced in FIG. 3. In FIG. 11, union 133 implements the union of all the signatures, which can now be resolved with the information provided in SCB(Tj). If the union 133 returns a FALSE statement, then no further analysis is required for this connection; otherwise, SCB(Tj) is passed to an event classifier (the slow path 132), which resolves each signature separately to determine which of them is triggered, leading to the set of specific events that must be invoked.

One advantage of the above method resides in its scalability. FIG. 12 shows how the performance of the system scales up with the number of signatures and protocols supported. The illustration makes an important assumption: that the execution of events is negligible with respect to the end-to-end cost of executing the complete workflow in FIG. 11. This assumption is more likely to be true in systems that focus on the passive analysis of the network traffic (for instance, in intrusion detection systems) and less likely to hold when the system performs heavy duty tasks for each event (for instance, in intrusion detection and prevention systems). It is also most likely to hold for network traffic patterns where flows that generate events occupy a small percentage of the total traffic. Because in some embodiments, each connection is only parsed once, regardless of the number of signatures, the system yields a flat region of operation. Within this region, the performance is invariant with respect to the number of signatures. This flat region has a saturation point, which defines the maximum number of signatures beyond which the performance will start to degrade. As long as the system operates within the flat region, the performance is invariant with respect the number of signatures. The performance also depends on the number of protocols supported, because for each protocol the system will replicate the infrastructure in FIG. 11. As shown, the performance will degrade as the number of protocols increases.

In another embodiment of the present invention, a method to generate DFA specifications 305 capable of resolving large number of signatures in parallel is illustrated in FIG. 13. (J. Ros-Giralt, J. Ezick, P. Szilagyi, R. Lethin, High-Speed Parallel Processing of Protocol-Aware Signatures, Thirteenth Annual Workshop of High Performance Embedded Computing, 2009, which is incorporated herein in its entirety.) In this method, a signature is modeled as a Boolean function and the objective is to find a DFA specification than can map such input into N DFA engines, with N larger or equal to 1. A signature or the union of more than one signature 301 is first treated by CNF generator 302, which interprets its input as a Boolean function and converts it into conjunctive normal form (CNF). This CNF expression is then treated by CNF partitioner 303, which partitions it into N smaller CNF expressions following a predefined optimization criteria. The output of this module is then processed by BDD converter 304, which converts each CNF expression into a binary decision diagram (BDD), yielding N BDDs. Since BDDs are a form of DFA specifications 305, this outcome can be directly loaded onto a set of N DFA engines. In some embodiments, the method includes a feedback loop between BDD converter 304 and CNF partitioner 303 to allow for an iterative optimization process in which if the output is not good enough, it can be fed back to the CNF partitioner 303 which can then adjust the partition in search for an optimal outcome. As it will be made evident in the following embodiments, a variety of metrics can be implemented, including but not limited to the maximum number of signatures that can be mapped onto a fixed-size DFA engine or the resulting average throughput of the system.

Turning to FIGS. 14, 15, 16, 17, 18 and 19 which describe a reduction to practice of an embodiment of the method presented in FIG. 13. Block 310 in FIG. 14 shows an example of a signature expressed in its Boolean form. The signature is expressed as a function of certain HTTP protocol header fields. Block 311 shows a pseudo-code implementation of the signature using a language called SALT™ which is described in “J. Ezick, Salt 1.5 Closing the Programming Gap for Boolean Satisfiability Solvers”, Reservoir White Paper, August 2007, which is incorporated by reference herein in its entirety. In FIG. 15, block 315 shows the CNF representation; this would correspond to an instance of an output of block 302 in FIG. 13. In this block, lines that start with the keyword “c” are comments, and the rest of the lines correspond to the clauses of the CNF. Each integer identifies an input binary variable of the original signature, except for the last integer, which is always 0 and defines the end of a clause, and negative signs represent the negation of a variable. Hence, the CNF expression in block 315 is as follows:

bit1=bit2=bit3=bit4=0; and

(bit6∩bit7∩bit9)∪(bit6∩bit7∩bit8)∪(̂bit5∩bit6∩bit9)∪(̂bit5∩bit6∩bit8)∪(bit5∩bit7∩bit9)∪(bit5∩bit7∩bit8),

where ∩, ∪ and ̂ represent logical operators AND, OR and NEGATION, respectively.

Block 316 in FIG. 15 shows a BDD representation of this CNF expression written in the BuDDy language which is described in J. Lind-Nielsel, “BuDDy: Binary Decision Diagram Package”, manual white paper, November 2002. In FIG. 16, a graphical representation of this BDD is presented. Next, suppose that this BDD is to be mapped onto three DFA engines. In this instance, some embodiments follow different optimizations criteria. For instance, FIG. 17 presents a partition of the initial BDD into three smaller BDDs that prove to be min-max, i.e. that the maximum number of nodes of any of the BDDs is minimal. The final DFA specification can be obtained by OR-ing the output of these three BDDs.

In another exemplary embodiment, FIG. 18 provides an optimization method for the partitioning of the BDDs based on the following constraints: (1) there exist two DFA engines, represented by E1 and E2; (2) DFA engine E1 has unlimited amount of memory whereas DFA engine E2 has bounded amount of memory; and (3) the usage of DFA engine E2 should be maximal. One embodiment of this configuration corresponds to a host computer configured with a DFA hardware acceleration engine. In this case, E1 could be implemented as a regular expression software library running on the host, which would effectively enjoy unlimited amounts of memory, and E2 would correspond to the hardware DFA engine, with limited amounts of embedded memory.

In FIG. 18, S1 and S2 correspond to the set of clauses of the BDDs that are to be mapped on E1 and E2 respectively, computeBDD(S) is a function that emits a BDD given a CNF expression S, shiftClauses (S1, S2) is a function that moves a subset of clauses from S2 to S1 following a certain optimization criterion, and the target size is defined as the maximum BDD size allowed by E2. The method starts at 330 with S1 being initialized with the complete CNF expression and S2 being empty. First, computeBDD module 331 calculates the BDD for S2. In 332, If its size is equal to the target size or within a tolerance, then the method terminates at 336; else if it is determined in 332 that the size is larger than the target size, at 334 clauses are shifted from S2 to S1 and the method returns to 331; otherwise, the size is smaller and at 333 it is determined if S1 is empty. If it is empty, the method terminates at 336; otherwise, clauses are shifted from S1 to S2 at 335 and the method returns to 331.

FIG. 19 illustrates a provided embodiment of a method for describing the implementation of the function shiftClauses introduced in FIG. 18. At 350, each input binary variable is assigned its probability of occurrence based on empirical analysis of real traffic patterns. For instance, in HTTP traffic, most transactions carry a GET request, so bit1 (FIG. 14) should be expected to have a fairly large probability. Once the probabilities of each variable are assigned, the probability of each clause P(clause-i) is calculated at 351. At 352 the function shiftClauses uses this information to ensure that those clauses that have the highest probability of being true are mapped onto those DFA engines that are faster. For instance in the embodiment presented in FIG. 18, E2 is faster than E1, hence shiftClauses aims at offloading those clauses that have the highest probability onto E2. By doing so, the probability that E2 returns a true statement is maximized, which minimizes the number of times that E1 needs to be invoked (notice that E1 only needs to be invoked when E2 returns zero).

In yet another provided embodiment, the logic order of the systems presented in FIGS. 14, 15, 16, 17, 18 and 19 are reversed, producing different sets of DFA specifications that are logically equivalent.

Illustrated in FIG. 20 are computing apparatus and computer software products consistent with provided embodiments. Computing apparatus 720 includes processor 660, memory 670, storage medium 680, and in some embodiments input port 690 and network interface 710. In many provided embodiments, non-transitory storage medium 680 contains a set of processor executable instructions that when executed by processor 660 configure computing apparatus 720 to implement the modules and methods described herein. In one embodiment, storage medium 680, containing the set of processor executable instructions resides in another computing apparatus 720 across network 730. In an embodiment of a computer software product, computer software product 700 is a computer readable storage medium containing processor executable instructions sufficient that when executed by processor 660 configure computing apparatus 720 to implement the above described modules and methods. Further, computer software product, in some embodiments consists of a physical medium configured to interface with input port 690 to allow its contents to be copied to storage medium 680. In other embodiments, computer software product 700 is an internal storage medium, such as 680. An additional embodiment of computing apparatus 720 includes a plurality of processors 680(a-n), a plurality of memories 670(a-n), a storage medium 680 and in some embodiments input port 690 and network connection 710. In some embodiments, one or more processors 680(a-n) is a host, while others are modeled in the form of a grid.

Thus, it is seen that methods apparatus and computer software products for implementation of high-speed network analyzers is provided. One skilled in the art will appreciate that embodiments of the present invention can be practiced by other than the above-described embodiments, which are presented in this description for purposes of illustration and not of limitation. The specification and drawings are not intended to limit the exclusionary scope of this patent document. It is noted that various equivalents for the particular embodiments discussed in this description may practice the invention as well. That is, while the present invention has been described in conjunction with specific embodiments, it is evident that many alternatives, modifications, permutations and variations will become apparent to those of ordinary skill in the art in light of the foregoing description. Accordingly, it is intended that the present invention embrace all such alternatives, modifications and variations as fall within the scope of the appended claims. The fact that a product, process or method exhibits differences from one or more of the above-described exemplary embodiments does not mean that the product or process is outside the scope (literal scope and/or other legally-recognized scope) of the following claims. 

1. A method of analyzing data in a communication device comprising: receiving, at a protocol input interface, a protocol specification; receiving, at an event interface, an event specification; deriving, in a network analyzer compiler module, a data plane specification from the protocol specification and the event specification; and outputting the data plane specification to a data plane module, wherein the data plane specification comprises a plurality of target events and the data plane module groups the target events into a fast path and a slow path and wherein the fast path implements a logical OR of at least two of the plurality of target events and the slow path implements each of the plurality of target events individually.
 2. The method of claim 1, wherein the event specification comprises at least one target signature and an action to be invoked when the at least one target signature is triggered.
 3. The method of claim 2, wherein the event specification is derived by receiving, at a signature generation module, a first communication packet; tracing; by the signature generation module, an action triggered by the first communication packet; and deriving a signature from the trace, wherein the signature comprises a function that is configured to receive second communication packet as an input.
 4. The method of claim 3, wherein the function is a Boolean function and is further configured to return a TRUE value if one of the at least one target signatures are present in the second communication packet.
 5. The method of claim 3, wherein the derivation of the event specification further comprises translating the function, in a source to source signature compiler, in to an equivalent signature compatible with a computer compiler system.
 6. The method of claim 5, wherein the deriving a data plane specification further comprises packing, in an event packing module, at least one equivalent signature with the action to be invoked when the at least one equivalent signature is triggered.
 7. The method of claim 1, wherein the protocol specification comprises a specification expressed in a high-level protocol specification language.
 8. The method of claim 1, wherein the deriving a data plane specification further comprises scanning the protocol specification and the event specification for regular expressions and generating statements in the data plane specification that assign the regular expressions to a specialized regular expression processing engine.
 9. The method of claim 1, wherein the deriving a data plane specification further comprises scanning the protocol specification and the event specification for regular expressions and generating statements in data plane specification that are capable of software processing the regular expressions.
 10. The method of claim 1, wherein the data plane module comprises a component selected from a group consisting of: a Field Programmable Gate Array, a General Purpose Processor, an Application Specific Integrated Circuit; and a Discrete Finite Automata engine.
 11. The method of claim 1, wherein the data plane module comprises a Discrete Finite Automata engine, the deriving a data plane specification further comprising (a) translating a Boolean signature into its conjunctive normal form expression; (b) partitioning, according to a first optimization criterion, the conjunctive normal form expression into a multiplicity of conjunctive normal form sub-expressions; (c) converting the multiplicity of conjunctive normal form sub-expressions into binary decision diagrams; and (d) representing the binary decision diagrams as Discrete Finite Automata specifications.
 12. The method of claim 11, further comprising (e) evaluating the Discrete Finite Automata specification against a second optimization criterion; and (f) iterating (a) through (e) until the evaluation is satisfactory.
 13. The method of claim 11, wherein the partitioning comprises computing a set of binary decision diagrams such that the number of nodes of the largest binary decision diagram is minimized.
 14. The method of claim 11, wherein the partitioning utilizes probabilities of occurrence of each bit of the input Boolean signatures to maximize the average throughput of the system.
 15. The method of claim 1, wherein the data plane module comprises a dispatcher module and a network analyzer module.
 16. The method of claim 15, wherein the dispatcher module and the network analyzer module share control information through a common storage facility.
 17. The method of claim 16, wherein the common storage facility comprises a structure selected from a group consisting: of a memory cache, a hash table, a bloom filter, a list, and a binary tree.
 18. The method of claim 16, further comprising: receiving at least one data packet; defining a pointer to one of the at least one data packet; and using the pointer to store data related to the packet in the common storage facility.
 19. The method of claim 18, further comprising using the pointer to fetch data related to the packet from the common storage facility.
 20. The method of claim 16 further comprising receiving a data packet and storing a record in the storage facility, the record comprising information shared between the dispatcher module and the network analyzer module, the shared information comprising an offset of a regular expression within the data packet, obtained by the network analyzer module.
 21. A custom analysis apparatus comprising: a processor; and a memory communicating with the processor, the memory containing a set of processor executable instruction that, when executed by the processor configure the custom analysis apparatus to: receive, at a protocol input interface, a protocol specification; receive, at an event interface, an event specification; derive, in a network analyzer compiler module, a data plane specification from the protocol specification and the event specification; and output the data plane specification to a data plane module, wherein the data plane specification comprises a plurality of target events and the data plane module groups the target events into a fast path and a slow path and wherein the fast path implements a logical OR of at least two of the plurality of target events and the slow path implements each of the plurality of target events individually.
 22. The custom analysis apparatus of claim 21, wherein the event specification comprises at least one target signature and an action to be invoked when the at least one target signature is triggered.
 23. The custom analysis apparatus of claim 22, wherein the configuration to derive an event specification is a configuration to receive, at a signature generation module, a first communication packet; trace; by the signature generation module, an action triggered by the first communication packet; and derive a signature from the trace, wherein the signature comprises a function that is configured to receive second communication packet as an input.
 24. The custom analysis apparatus of claim 23, wherein the function is a Boolean function and is further configured to return a TRUE value if one of the at least one target signatures are present in the second communication packet.
 25. The custom analysis apparatus of claim 23, wherein the configuration to derive the event specification further comprises a configuration to translate the function, in a source to source signature compiler, into an equivalent signature compatible with a computer compiler system.
 26. The custom analysis apparatus of claim 25, wherein the configuration to derive a data plane specification further comprises a configuration to pack, in an event packing module, at least one equivalent signature with the action to be invoked when the at least one equivalent signature is triggered.
 27. The custom analysis apparatus of claim 21, wherein the protocol specification comprises a specification expressed in a high-level protocol specification language.
 28. The custom analysis apparatus of claim 21, wherein the configuration to derive a data plane specification further comprises a configuration to scan the protocol specification and the event specification for regular expressions and generate statements in the data plane specification that assign the regular expressions to a specialized regular expression processing engine.
 29. The custom analysis apparatus of claim 21, wherein the configuration to derive a data plane specification further comprises a configuration to scan the protocol specification and the event specification for regular expressions and generate statements in data plane specification that are capable of software processing the regular expressions.
 30. The custom analysis apparatus of claim 21, wherein the data plane module comprises a component selected from a group consisting of: a Field Programmable Gate Array, a General Purpose Processor, an Application Specific Integrated Circuit; and a Discrete Finite Automata engine.
 31. The custom analysis apparatus of claim 21, wherein the data plane module comprises a Discrete Finite Automata engine, the configuration to derive a data plane specification further comprises a configuration to (a) translate a Boolean signature into its conjunctive normal form expression; (b) partition, according to a first optimization criterion, the conjunctive normal form expression into a multiplicity of conjunctive normal form sub-expressions; (c) convert the multiplicity of conjunctive normal form sub-expressions into binary decision diagrams; and (d) represent the binary decision diagrams as Discrete Finite Automata specifications.
 32. The custom analysis apparatus of claim 31, wherein the configuration further comprises a configuration to (e) evaluate the Discrete Finite Automata specification against a second optimization criterion; and (f) iterate (a) through (e) until the evaluation is satisfactory.
 33. The custom analysis apparatus of claim 31, wherein the configuration to partition comprises a configuration to compute a set of binary decision diagrams such that the number of nodes of the largest binary decision diagram is minimized.
 34. The custom analysis apparatus of claim 31, wherein the configuration to partition utilizes probabilities of occurrence of each bit of the input Boolean signatures to maximize the average throughput of the system.
 35. The custom analysis apparatus of claim 31, wherein the data plane module comprises a dispatcher module and a network analyzer module.
 36. The custom analysis apparatus of claim 35, wherein the dispatcher module and the network analyzer module share control information through a common storage facility.
 37. The custom analysis apparatus of claim 36, wherein the common storage facility comprises a structure selected from a group consisting: of a memory cache, a hash table, a bloom filter, a list, and a binary tree.
 38. The custom analysis apparatus of claim 36, wherein the configuration further comprises a configuration to: receive at least one data packet; define a pointer to one of the at least one data packet; and use the pointer to store data related to the packet in the common storage facility.
 39. The custom analysis apparatus of claim 38, wherein the configuration further comprises a configuration to use the pointer to fetch data related to the packet from the common storage facility.
 40. The custom analysis apparatus of claim 36, wherein the configuration further comprises a configuration to receive a data packet and store a record in the storage facility, the record comprising information shared between the dispatcher module and the network analyzer module, the shared information comprising an offset of a regular expression within the data packet, obtained by the network analyzer module.
 41. An article of manufacture comprising a non-transitory computer readable medium, the non-transitory computer readable medium containing a set of processor executable instructions, the set of processor executable instructions sufficient that, when executed by a processor configure a analysis apparatus to: receive, at a protocol input interface, a protocol specification; receive, at an event interface, an event specification; derive, in a network analyzer compiler module, a data plane specification from the protocol specification and the event specification; and output the data plane specification to a data plane module, wherein the data plane specification comprises a plurality of target events and the data plane module groups the target events into a fast path and a slow path and wherein the fast path implements a logical OR of at least two of the plurality of target events and the slow path implements each of the plurality of target events individually.
 42. The article of manufacture of claim 41, wherein the event specification comprises at least one target signature and an action to be invoked when the at least one target signature is triggered.
 43. The article of manufacture of claim 42, wherein the configuration to derive an event specification is a configuration to receive, at a signature generation module, a first communication packet; trace; by the signature generation module, an action triggered by the first communication packet; and derive a signature from the trace, wherein the signature comprises a function that is configured to receive second communication packet as an input.
 44. The article of manufacture of claim 43, wherein the function is a Boolean function and is further configured to return a TRUE value if one of the at least one target signatures are present in the second communication packet.
 45. The article of manufacture of claim 43, wherein the configuration to derive the event specification further comprises a configuration to translate the function, in a source to source signature compiler, in to an equivalent signature compatible with a computer compiler system.
 46. The article of manufacture of claim 45, wherein the configuration to derive a data plane specification further comprises a configuration to pack, in an event packing module, at least one equivalent signature with the action to be invoked when the at least one equivalent signature is triggered.
 47. The article of manufacture of claim 41, wherein the protocol specification comprises a specification expressed in a high-level protocol specification language.
 48. The article of manufacture of claim 41, wherein the configuration to derive a data plane specification further comprises a configuration to scan the protocol specification and the event specification for regular expressions and generate statements in the data plane specification that assign the regular expressions to a specialized regular expression processing engine.
 49. The article of manufacture of claim 41, wherein the configuration to derive a data plane specification further comprises a configuration to scan the protocol specification and the event specification for regular expressions and generate statements in data plane specification that are capable of software processing the regular expressions.
 50. The article of manufacture of claim 41, wherein the data plane module comprises a component selected from a group consisting of: a Field Programmable Gate Array, a General Purpose Processor, an Application Specific Integrated Circuit; and a Discrete Finite Automata engine.
 51. The article of manufacture of claim 41, wherein the data plane module comprises a Discrete Finite Automata engine, the configuration to derive a data plane specification further comprises a configuration to (a) translate a Boolean signature into its conjunctive normal form expression; (b) partition, according to a first optimization criterion, the conjunctive normal form expression into a multiplicity of conjunctive normal form sub-expressions; (c) convert the multiplicity of conjunctive normal form sub-expressions into binary decision diagrams; and (d) represent the binary decision diagrams as Discrete Finite Automata specifications.
 52. The article of manufacture of claim 51, wherein the configuration further comprises a configuration to (e) evaluate the Discrete Finite Automata specification against a second optimization criterion; and (f) iterate (a) through (e) until the evaluation is satisfactory.
 53. The article of manufacture of claim 51, wherein the configuration to partition comprises a configuration to compute a set of binary decision diagrams such that the number of nodes of the largest binary decision diagram is minimized.
 54. The article of manufacture of claim 51, wherein the configuration to partition utilizes probabilities of occurrence of each bit of the input Boolean signatures to maximize the average throughput of the system.
 55. The article of manufacture of claim 51, wherein the data plane module comprises a dispatcher module and a network analyzer module.
 56. The article of manufacture of claim 55, wherein the dispatcher module and the network analyzer module share control information through a common storage facility.
 57. The article of manufacture of claim 56, wherein the common storage facility comprises a structure selected from a group consisting: of a memory cache, a hash table, a bloom filter, a list, and a binary tree.
 58. The article of manufacture of claim 56, wherein the configuration further comprises a configuration to: receive at least one data packet; define a pointer to one of the at least one data packet; and use the pointer to store data related to the packet in the common storage facility.
 59. The article of manufacture of claim 58, wherein the configuration further comprises a configuration to use the pointer to fetch data related to the packet from the common storage facility.
 60. The article of manufacture of claim 56, wherein the configuration further comprises a configuration to receive a data packet and store a record in the storage facility, the record comprising information shared between the dispatcher module and the network analyzer module, the shared information comprising an offset of a regular expression within the data packet, obtained by the network analyzer module. 